home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / fish / 676-700 / 681 / term / source.lha / termGlobal.h < prev    next >
C/C++ Source or Header  |  1992-05-09  |  43KB  |  1,529 lines
  1. /*
  2. **    $Id: termGlobal.h,v 1.10 92/05/08 20:49:55 olsen Sta Locker: olsen $
  3. **    $Revision: 1.10 $
  4. **    $Date: 92/05/08 20:49:55 $
  5. **
  6. **    Global data definitions and function forward declarations
  7. **
  8. **    Copyright © 1990-1992 by Olaf `Olsen' Barthel & MXM
  9. **        All Rights Reserved
  10. */
  11.  
  12. #include "xproto.h"
  13. #include "xem.h"
  14.  
  15.     /* Menu item codes. */
  16.  
  17. enum    {    MEN_OPEN=1,MEN_SAVE,MEN_SAVEAS,MEN_PRINTSCREEN,MEN_ICONIFY,MEN_ABOUT,MEN_QUIT,
  18.         MEN_SETCONSOLE,MEN_DOSCOMMAND,MEN_REXXCOMMAND,MEN_EDIT,MEN_PASTE,MEN_PACKET,MEN_FASTMACROPANEL,
  19.         MEN_CLEARBUFFER,MEN_DISPLAYBUFFER,MEN_CLOSEBUFFER,MEN_FREEZEBUFFER,MEN_LOADBUFFER,MEN_SAVEBUFFER,MEN_CAPTUREDISK,MEN_CAPTUREPRINTER,
  20.         MEN_UPLOADTEXT,MEN_DOWNLOADTEXT,MEN_SEND,MEN_RECEIVE,MEN_UPLOAD,MEN_DOWNLOAD,MEN_XFERPROTOCOL,MEN_SELECTXFER,
  21.         MEN_PHONEBOOK,MEN_DIAL,MEN_REDIAL,MEN_PLAY,MEN_SENDBREAK,MEN_FLUSHBUFFER,MEN_HANGUP,MEN_RELEASE,
  22.         MEN_CLEARSCREEN,MEN_RESETSTYLES,MEN_RESETFONT,MEN_RESETTERMINAL,MEN_SAVEILBM,MEN_SAVEASCII,
  23.         MEN_SERIAL,MEN_MODEM,MEN_TRANSFER,MEN_FASTMACROS,MEN_MACROS,MEN_SCREEN,MEN_TERMINAL,MEN_COMMANDS,MEN_EMULATION,MEN_PATH,MEN_MISC,MEN_HOTKEYS,MEN_SPEECH };
  24.  
  25.     /* Serial settings. */
  26.  
  27. enum    {    PARITY_NONE,PARITY_EVEN,PARITY_ODD,PARITY_MARK,PARITY_SPACE };
  28. enum    {    HANDSHAKING_XONXOFF,HANDSHAKING_RTSCTS,HANDSHAKING_NONE,HANDSHAKING_RTSCTS_DSR };
  29. enum    {    DUPLEX_FULL,DUPLEX_HALF };
  30.  
  31.     /* Terminal settings. */
  32.  
  33. enum    {    CR_IGNORE,CR_ASCR,CR_ASCRLF };
  34. enum    {    LF_IGNORE,LF_ASLF,LF_ASLFCR };
  35. enum    {    EMULATION_ANSIVT100,EMULATION_ATOMIC,EMULATION_TTY,EMULATION_EXTERNAL };
  36. enum    {    COLOUR_AMIGA,COLOUR_EIGHT,COLOUR_SIXTEEN,COLOUR_MONO };
  37.  
  38.     /* Protocol types. */
  39.  
  40. enum    {    PROTOCOL_XMODEM,PROTOCOL_XMODEMCRC,PROTOCOL_YMODEM,PROTOCOL_ZMODEM };
  41.  
  42.     /* Font types. */
  43.  
  44. enum    {    FONT_TOPAZ,FONT_IBM };
  45.  
  46.     /* Status types. */
  47.  
  48. enum    {    STATUS_READY,STATUS_HOLDING,STATUS_DIALING,STATUS_UPLOAD,
  49.         STATUS_DOWNLOAD,STATUS_BREAKING,STATUS_HANGUP };
  50.  
  51.     /* Status line modes. */
  52.  
  53. enum    {    STATUSLINE_DISABLED,STATUSLINE_STANDARD,STATUSLINE_COMPRESSED };
  54.  
  55.     /* Font scales. */
  56.  
  57. enum    {    SCALE_NORMAL,SCALE_HALF };
  58. enum    {    SCALE_ATTR_NORMAL,SCALE_ATTR_TOP2X,SCALE_ATTR_BOT2X,SCALE_ATTR_2X };
  59.  
  60.     /* Character tables. */
  61.  
  62. enum    {    TABLE_ASCII,TABLE_GFX };
  63.  
  64.     /* Transfer types. */
  65.  
  66. enum    {    TRANSFER_BINARY,TRANSFER_TEXT,TRANSFER_ASCII };
  67.  
  68.     /* Upload panel actions. */
  69.  
  70. enum    {    UPLOAD_TEXT=1,UPLOAD_BINARY,UPLOAD_IGNORE,UPLOAD_ABORT };
  71.  
  72.     /* Day of week flags. */
  73.  
  74. #define DAY_MONDAY    (1 << 0)
  75. #define DAY_TUESDAY    (1 << 1)
  76. #define DAY_WEDNESDAY    (1 << 2)
  77. #define DAY_THURSDAY    (1 << 3)
  78. #define DAY_FRIDAY    (1 << 4)
  79. #define DAY_SATURDAY    (1 << 5)
  80. #define DAY_SUNDAY    (1 << 6)
  81.  
  82.     /* These signal masks will make life a bit easier. */
  83.  
  84. #define SIG_WINDOW    (1 << Window -> UserPort -> mp_SigBit)
  85. #define SIG_REXX    (1 << TermRexxPort -> mp_SigBit)
  86. #define SIG_SERIAL    (1 << ReadPort -> mp_SigBit)
  87. #define SIG_PACKET    (1 << PacketWindow -> UserPort -> mp_SigBit)
  88. #define SIG_TIMER    (1 << TimePort -> mp_SigBit)
  89. #define SIG_AUDIO    (1 << AudioBlock -> ioa_Request . io_Message . mn_ReplyPort -> mp_SigBit)
  90. #define SIG_REVIEW    ((1 << ReviewPort -> mp_SigBit) | (1 << ReviewWindow -> UserPort -> mp_SigBit))
  91. #define SIG_CLIP    SIGBREAKF_CTRL_E
  92.  
  93.     /* Some support macros for gadtools objects. */
  94.  
  95. #define GT_CHECKED(G)    ((((struct Gadget *)(G)) -> Flags & GFLG_SELECTED) ? TRUE : FALSE)
  96. #define GT_DISABLED(G)    ((((struct Gadget *)(G)) -> Flags & GFLG_DISABLED) ? TRUE : FALSE)
  97. #define GT_STRING(G)    (((struct StringInfo *)(((struct Gadget *)(G)) -> SpecialInfo)) -> Buffer)
  98. #define GT_INTEGER(G)    (((struct StringInfo *)(((struct Gadget *)(G)) -> SpecialInfo)) -> LongInt)
  99.  
  100.     /* Definitions to access the line signal setting functions supported by
  101.      * some IO serial boards (namely the ASDG board).
  102.      */
  103.  
  104. #define SIOCMD_SETCTRLLINES    (CMD_NONSTD + 7)
  105. #define SIOB_RTSB        0
  106. #define SIOB_DTRB        1
  107. #define SIOB_RTSF        (1 << SIOB_RTSB)
  108. #define SIOB_DTRF        (1 << SIOB_DTRB)
  109.  
  110.     /* Kludge: this bit indicates that the shared serial access is enabled. */
  111.  
  112. #define SERIAL_SHARED        2
  113.  
  114.     /* YAK (Yet Another Kludge): this bit indicates that a somewhat simpler
  115.      * and faster screen layout is to be used.
  116.      */
  117.  
  118. #define TERMINAL_FASTER        2
  119.  
  120.     /* Special character treatment. */
  121.  
  122. struct SpecialKey
  123. {
  124.     UBYTE    Key;
  125.     VOID    (*Routine)();
  126. };
  127.  
  128.     /* Cursor backup data. */
  129.  
  130. struct CursorData
  131. {
  132.     struct TextFont    *CurrentFont;
  133.     WORD         CursorX,
  134.              CursorY;
  135.     BYTE         Charset;
  136.     BYTE         CharMode[2];
  137.     BYTE         Attributes;
  138.     BYTE         FgPen,
  139.              BgPen;
  140.     UBYTE         Style;
  141. };
  142.  
  143.     /* Global data link. */
  144.  
  145. struct TermPort
  146. {
  147.     struct MsgPort         ExecNode;
  148.  
  149.     struct Window        *TopWindow;
  150.  
  151.     struct SignalSemaphore     OpenSemaphore;
  152.  
  153.     LONG             ID,OpenCount,HoldIt;
  154.     LONG             Reserved[5];
  155. };
  156.  
  157.     /* Support for optimized scrolling routines. */
  158.  
  159. struct ScrollLineInfo
  160. {
  161.     UBYTE         Left,Right;
  162.     UBYTE         ColourMask;
  163.     UBYTE         Shift;
  164. };
  165.  
  166.     /* A dial list entry. */
  167.  
  168. struct PhoneNode
  169. {
  170.     struct Node         VanillaNode;
  171.  
  172.     UBYTE             LocalName[50];
  173.  
  174.     struct PhoneEntry    *Entry;
  175. };
  176.  
  177.     /* A Fast! macro list entry. */
  178.  
  179. struct MacroNode
  180. {
  181.     struct MacroNode    *mn_Succ;    /* Modeled after the default Node. */
  182.     struct MacroNode    *mn_Pred;
  183.  
  184.     WORD             mn_Pad;    /* Included only for Node compatibility. */
  185.  
  186.     UBYTE            *mn_Macro;    /* = ln_Name, title */
  187.     UBYTE            *mn_Code;    /* The execution code. */
  188. };
  189.  
  190.     /* Speech preferences. */
  191.  
  192. struct SpeechConfig
  193. {
  194.     WORD    Rate;
  195.     WORD    Pitch;
  196.     LONG    Frequency;
  197.     BYTE    Sex;
  198.     BYTE    Volume;
  199.     BYTE    Enabled;
  200.     BYTE    Pad;
  201. };
  202.  
  203.     /* Macro Preferences. */
  204.  
  205. struct MacroKeys
  206. {
  207.     UBYTE    Keys[4][10][256];
  208. };
  209.  
  210.     /* term configuration. */
  211.  
  212. struct Configuration
  213. {
  214.     /* Serial Preferences. */
  215.  
  216.     ULONG    BaudRate;
  217.     BYTE    BitsPerChar;
  218.     BYTE    Parity;
  219.     BYTE    StopBits;
  220.     BYTE    Handshaking;
  221.     BYTE    Duplex;
  222.     BYTE    HighSpeed;
  223.     ULONG    BreakLength;
  224.     UBYTE    SerialDevice[40];
  225.     LONG    UnitNumber;
  226.  
  227.     /* Modem Preferences. */
  228.  
  229.     UBYTE    ModemInit[80];
  230.     UBYTE     ModemExit[80];
  231.     UBYTE     ModemHangup[80];
  232.     UBYTE    DialPrefix[80];
  233.     LONG    RedialDelay;
  234.     LONG    DialRetries;
  235.     LONG    DialTimeout;
  236.     BYTE    ConnectAutoCapture;
  237.     BYTE    ConnectAutoBaud;
  238.     BYTE    LogActions;
  239.     UBYTE    NoCarrier[16];
  240.     UBYTE    Connect[16];
  241.     UBYTE    Voice[16];
  242.     UBYTE    Ring[16];
  243.     UBYTE    Busy[16];
  244.  
  245.     /* Transfer Preferences. */
  246.  
  247.     UBYTE    Protocol[40];
  248.  
  249.     /* Startup macro. */
  250.  
  251.     UBYTE    StartupMacro[256];
  252.  
  253.     /* Macro Preferences. */
  254.  
  255.     UBYTE    MacroFile[256];
  256.  
  257.     /* Screen Preferences. */
  258.  
  259.     ULONG    DisplayMode;
  260.     UWORD    Colours[16];
  261.     BYTE    MakeScreenPublic;
  262.     BYTE    ShanghaiWindows;
  263.  
  264.     /* Terminal Preferences. */
  265.  
  266.     BYTE    CaptureFilter;
  267.     BYTE    DestructiveBackspace;
  268.     BYTE    AudibleBell;
  269.     BYTE    VisibleBell;
  270.     BYTE    EightyColumns;
  271.     BYTE    DisableBlinking;
  272.     BYTE    SendCR;
  273.     BYTE    SendLF;
  274.     BYTE    ColourMode;
  275.     BYTE    Emulation;
  276.     BYTE    Font;
  277.  
  278.     /* Emulation control. */
  279.  
  280.     BYTE    CursorApp;
  281.     BYTE    FontScale;
  282.     BYTE    JumpScroll;
  283.     BYTE    AutoWrap;
  284.     BYTE    CursorWrap;
  285.     BYTE    NewLine;
  286.     BYTE    InsertChar;
  287.     BYTE    NumApp;
  288.  
  289.     /* Path Preferences. */
  290.  
  291.     UBYTE    DefaultStorage[256];
  292.  
  293.     UBYTE    TextUploadPath[256];
  294.     UBYTE    TextDownloadPath[256];
  295.  
  296.     UBYTE    ASCIIUploadPath[256];
  297.     UBYTE    ASCIIDownloadPath[256];
  298.  
  299.     UBYTE    BinaryUploadPath[256];
  300.     UBYTE    BinaryDownloadPath[256];
  301.  
  302.     UBYTE    CapturePath[256];
  303.     UBYTE    LogFile[256];
  304.     UBYTE    Editor[256];
  305.     UBYTE    BeepSound[256];
  306.  
  307.     /* Extension in version 1.9b */
  308.  
  309.     BYTE    SwapBSDelete;
  310.     BYTE    StripBit8;
  311.  
  312.     /* Some more extensions... */
  313.  
  314.     BYTE    RasterEnabled;
  315.  
  316.     UBYTE    EmulationName[256];
  317.  
  318.     /* Up-/Download Macros. */
  319.  
  320.     UBYTE    UploadMacro[256];
  321.     UBYTE    DownloadMacro[256];
  322.  
  323.     /* Default fast! macro file. */
  324.  
  325.     UBYTE    FastMacroFile[256];
  326.  
  327.     /* Program priority. */
  328.  
  329.     BYTE    Priority;
  330.  
  331.     /* Override transfer path. */
  332.  
  333.     BYTE    OverridePath;
  334.  
  335.     /* Backup config between switching to phone entries. */
  336.  
  337.     BYTE    BackupConfig;
  338.  
  339.     /* ZModem auto upload panel enabled? */
  340.  
  341.     BYTE    AutoUpload;
  342.  
  343.     /* No dialtone string. */
  344.  
  345.     UBYTE    NoDialTone[16];
  346.  
  347.     /* Check carrier upon `CARRIER LOST' message. */
  348.  
  349.     BYTE    CheckCarrier;
  350.  
  351.     /* Display the screen title bar? */
  352.  
  353.     BYTE    TitleBar;
  354.  
  355.     /* Display the status lines? */
  356.  
  357.     BYTE    StatusLine;
  358.  
  359.     BYTE    DropDTR;
  360.  
  361.     /* Custom keymap file name. */
  362.  
  363.     UBYTE    KeyMapName[40];
  364.  
  365.     /* Serial buffer size. */
  366.  
  367.     LONG    SerBuffSize;
  368.  
  369.     /* Maximum log book buffer size. */
  370.  
  371.     LONG    MaxLogBuffSize;
  372.  
  373.     /* Is the buffering enabled? */
  374.  
  375.     BYTE    BufferEnabled;
  376.  
  377.     /* Receive CR/LF as... */
  378.  
  379.     BYTE    ReceiveCR;
  380.     BYTE    ReceiveLF;
  381.  
  382.     /* Set `archived' bit on uploaded files. */
  383.  
  384.     BYTE    SetArchivedBit;
  385.  
  386.     /* Open the fast! macro panel on startup? */
  387.  
  388.     BYTE    OpenFastMacroPanel;
  389.  
  390.     /* Pass xON/xOFF through to modem? */
  391.  
  392.     BYTE    PassThrough;
  393.  
  394.     /* Use system DisplayBeep()? */
  395.  
  396.     BYTE    SystemBeep;
  397.     BYTE    Pad;
  398.  
  399.     /* Answerback message. */
  400.  
  401.     UBYTE    AnswerBack[41];
  402.     BYTE    Pad2;
  403. };
  404.  
  405.     /* term hotkey configuration. */
  406.  
  407. struct Hotkeys
  408. {
  409.     UBYTE    termScreenToFront[256];
  410.     UBYTE    BufferScreenToFront[256];
  411.     UBYTE    SkipDialEntry[256];
  412.     BYTE    CommodityPriority;
  413.     BYTE    HotkeysEnabled;
  414.  
  415.     ULONG    Reserved[25];
  416. };
  417.  
  418.     /* The TimeDate structure */
  419.  
  420. struct TimeDate
  421. {
  422.     WORD    PayPerUnit[2];
  423.     WORD    SecPerUnit[2];
  424.  
  425.     WORD    TimeOfDay[2];
  426.  
  427.     BYTE    Month;        /* Month of year or -1 -> Day = bitmapped days of week. */
  428.     BYTE    Day;        /* Day of month or -1 -> standard settings. */
  429.  
  430.     UBYTE    Comment[22];    /* Comment for this entry. */
  431. };
  432.  
  433. struct TimeDateNode
  434. {
  435.     struct Node    VanillaNode;    /* Default node entry. */
  436.     UBYTE        Buffer[30];    /* Name buffer. */
  437.  
  438.     struct TimeDate    TimeDate;    /* The TimeDate structure. */
  439. };
  440.  
  441.     /* A phonebook entry. */
  442.  
  443. struct PhoneEntry
  444. {
  445.     struct PhoneNode    *Node;
  446.  
  447.     struct MinList         TimeDateList;
  448.  
  449.     LONG             Count;
  450.  
  451.     UBYTE             Name[30];
  452.     UBYTE             Number[40];
  453.     UBYTE             Password[20];
  454.     UBYTE             UserName[20];
  455.  
  456.     LONG             PayPerUnit[2];
  457.     LONG             SecPerUnit[2];
  458.     LONG             TimeOfDay[2];
  459.  
  460.     struct Configuration     Config;
  461. };
  462.  
  463.     /* Number of buffers to be used for buffered I/O. */
  464.  
  465. #define BUFFER_NUMBER 2
  466.  
  467.     /* Auxiliary structure for buffered file I/O. */
  468.  
  469. struct Buffer
  470. {
  471.     struct Message             Message;            /* Vanilla message header. */
  472.  
  473.     BYTE                 Read;                /* Last access has read data. */
  474.     BYTE                 Written;            /* Last access has written data. */
  475.  
  476.     LONG                 Action;            /* Action to perform. */
  477.     LONG                 ActionData[2];            /* Seek and the like. */
  478.     LONG                 Result;            /* Return value. */
  479.  
  480.     BPTR                 FileHandle;            /* Dos filehandle. */
  481.  
  482.     UBYTE                *Data;                /* Data buffer. */
  483.     LONG                 BufLength;            /* Length of data buffer. */
  484.  
  485.     LONG                 BufPosition;            /* Read/write pointer into buffer. */
  486.  
  487.     LONG                 ReadBufFull;            /* How many bytes are still to be read from the buffer? */
  488.     LONG                 WriteBufFull;            /* How many bytes are still to be written to the buffer?*/
  489.  
  490.     LONG                 RealPosition;            /* Real position in file. */
  491.     LONG                 Cached;            /* How many bytes in pre-load cache. */
  492.  
  493.     UBYTE                *DataBuffer[BUFFER_NUMBER];    /* The data buffers. */
  494.     LONG                 DataLength[BUFFER_NUMBER];    /* The lengths of the data buffers. */
  495.     WORD                 DataCount;            /* Which buffer to use. */
  496.     BYTE                 WriteAccess;            /* TRUE if a write file handle. */
  497.     BYTE                 LastActionFailed;        /* TRUE if last action failed -> abort actions. */
  498.  
  499.     struct Process            *Child;
  500.     struct Process            *Caller;            /* Synchronization. */
  501.  
  502.     BPTR                 DirLock;
  503.     struct InfoData __aligned     InfoData;
  504.  
  505.     BYTE                 Fresh;                /* TRUE if no read/write access has taken place yet. */
  506. };
  507.  
  508.     /* Global data flow <-> term interface. */
  509.  
  510. struct FlowInfo
  511. {
  512.     BYTE    Changed;
  513.  
  514.     BYTE    NoCarrier;
  515.     BYTE    ZModemUpload;
  516.  
  517.     BYTE    Connect;
  518.     BYTE    Voice;
  519.     BYTE    Ring;
  520.     BYTE    Busy;
  521.  
  522.     BYTE    NoDialTone;
  523. };
  524.  
  525.     /* A scan sequence, somewhat similar to the FlowInfo
  526.      * structure.
  527.      */
  528.  
  529. struct ScanNode
  530. {
  531.     struct MinNode     Node;
  532.  
  533.     UBYTE        *Sequence;    /* Character sequence to be matched. */
  534.     LONG         Count;        /* Number of characters matched. */
  535. };
  536.  
  537.     /* xpr serial bits. */
  538.  
  539. #define ST_PARTYON    (1 << 0)
  540. #define ST_PARTYODD    (1 << 1)
  541. #define ST_7WIRE    (1 << 2)
  542. #define ST_QBREAK    (1 << 3)
  543. #define ST_RADBOOGIE    (1 << 4)
  544. #define ST_SHARED    (1 << 5)
  545. #define ST_EOFMODE    (1 << 6)
  546. #define ST_XDISABLED    (1 << 7)
  547. #define ST_PARTYMARKON    (1 << 8)
  548. #define ST_PARTYMARK    (1 << 9)
  549. #define ST_2BITS    (1 << 10)
  550. #define ST_READ7    (1 << 11)
  551. #define ST_WRITE7    (1 << 12)
  552.  
  553.     /* Miscellaneous definitions. */
  554.  
  555. #define MILLION        1000000
  556.  
  557. #define    ATTR_UNDERLINE    1
  558. #define    ATTR_HIGHLIGHT    2
  559. #define ATTR_BLINK    4
  560. #define    ATTR_INVERSE    8
  561.  
  562.     /* Status macro (is character printable?). */
  563.  
  564. #define IsPrintable(c)    (ValidTab[(c)])
  565. #define IsControl(c)    (((c) > 127 && (c) < 160) ? TRUE : FALSE)
  566.  
  567.     /* Set the stopwatch pointer. */
  568.  
  569. #define SetWait(Window)    SetPointer((Window),&Stopwatch[0],16,16,-6,0)
  570.  
  571.     /* Audio channels. */
  572.  
  573. #define LEFT0F  1
  574. #define RIGHT0F  2
  575. #define RIGHT1F  4
  576. #define LEFT1F  8
  577.  
  578.     /* Program revision and the approriate info structure. */
  579.  
  580. struct TermInfo
  581. {
  582.     UWORD    Version;
  583.     UWORD    Revision;
  584. };
  585.  
  586. extern LONG    TermVersion,
  587.         TermRevision;
  588.  
  589. extern UBYTE    TermName[],
  590.         TermDate[];
  591.  
  592.     /* Beep.c */
  593.  
  594. BYTE                CreateBeep(VOID);
  595. VOID                DeleteBeep(VOID);
  596. VOID                ClearAudio(VOID);
  597. VOID                Beep(VOID);
  598. BYTE                OpenSound(UBYTE *Name);
  599.  
  600.     /* CommandPanel.c */
  601.  
  602. VOID                CommandPanel(struct Configuration *Config);
  603.  
  604.     /* Console.c */
  605.  
  606. VOID __regargs            CaptureToFile(APTR Buffer,LONG Size);
  607. VOID __regargs            Capture(APTR Buffer,LONG Size);
  608.  
  609. VOID                ClosePrinterCapture(BYTE Force);
  610. BYTE                OpenPrinterCapture(BYTE Controller);
  611. VOID                PrintRegion(WORD Top,WORD Bottom);
  612.  
  613. BYTE __regargs            HandleCursor(UBYTE Char);
  614.  
  615. VOID                DoBackspace(VOID);
  616. VOID                DoSomeBeep(VOID);
  617.  
  618. VOID                DoLF(VOID);
  619. VOID                DoIgnore(VOID);
  620. VOID                DoShiftIn(VOID);
  621. VOID                DoShiftOut(VOID);
  622. VOID                DoCR_LF(VOID);
  623. VOID                DoFF(VOID);
  624. VOID                DoLF_FF_VT(VOID);
  625. VOID                DoCR(VOID);
  626. VOID                DoTab(VOID);
  627. VOID                DoEnq(VOID);
  628.  
  629. VOID __regargs            GfxText(struct RastPort *RPort,STRPTR Buffer,LONG Length);
  630.  
  631. VOID __regargs            ConWrite(APTR Buffer,LONG Size);
  632. VOID __regargs            ConProcess(UBYTE *String,LONG Size);
  633. VOID __stdargs            ConWrites(UBYTE *String,...);
  634. UBYTE __regargs            KeyConvert(struct IntuiMessage *Massage,UBYTE *Buffer,LONG *Len);
  635.  
  636.     /* CopyPanel.c */
  637.  
  638. VOID                CopyPanel(struct Configuration *MyConfig);
  639.  
  640.     /* DatePanel.c */
  641.  
  642. BYTE                DatePanel(struct TimeDate *TimeDate);
  643.  
  644.     /* DayPanel.c */
  645.  
  646. BYTE                DayPanel(struct TimeDate *TimeDate);
  647.  
  648.     /* DialPanel.c */
  649.  
  650. BYTE                DialPanel(VOID);
  651.  
  652.     /* FastMacros.c */
  653.  
  654. VOID                RefreshFastWindow(WORD Height);
  655. VOID                CloseFastWindow(VOID);
  656. BYTE                OpenFastWindow(VOID);
  657. struct MacroNode *        NewFastMacro(UBYTE *Macro,UBYTE *Code);
  658. VOID                RemFastMacro(struct MacroNode *Node);
  659. struct MacroNode *        GetFastMacro(LONG Offset);
  660. VOID                ClearFastMacroList(struct List *List);
  661. LONG                GetFastMacroOffset(struct MacroNode *MacroNode);
  662. VOID __regargs            MoveList(struct List *From,struct List *To);
  663. BYTE                SaveFastMacros(UBYTE *Name);
  664. BYTE                LoadFastMacros(UBYTE *Name);
  665.  
  666.     /* FastMacroPanel.c */
  667.  
  668. VOID                FastMacroPanel(VOID);
  669.  
  670.     /* FileBuffer.c */
  671.  
  672. LONG __stdargs            BPrintf(struct Buffer *Buffer,UBYTE *Format,...);
  673.  
  674. BYTE __regargs            BufferClose(struct Buffer *Buffer);
  675. struct Buffer * __regargs    BufferOpen(UBYTE *Name,UBYTE *AccessMode);
  676. LONG __regargs            BufferRead(struct Buffer *Buffer,UBYTE *Destination,LONG Size);
  677. LONG __regargs            BufferWrite(struct Buffer *Buffer,UBYTE *Source,LONG Size);
  678. BYTE __regargs            BufferSeek(struct Buffer *Buffer,LONG Offset,LONG Origin);
  679.  
  680.     /* GadgetSupport.c */
  681.  
  682. VOID                KeySelect(struct Gadget **GadgetList,WORD Last,UBYTE Key,struct Window *Window,struct Gadget **Gadget,ULONG *Class,ULONG *Code);
  683.  
  684.     /* Identify.c */
  685.  
  686. VOID                Identify(UBYTE *Name);
  687.  
  688.     /* ImportPanel.c */
  689.  
  690. VOID                ImportPanel(struct PhoneEntry *Entry,struct List *PhoneList);
  691.  
  692.     /* LocaleSupport.c */
  693.  
  694. VOID __regargs            LocaleOpen(STRPTR CatalogName,STRPTR BuiltIn,LONG Version);
  695. VOID                LocaleClose(VOID);
  696. VOID                LanguageCheck(VOID);
  697. WORD __regargs            GadToolsStrlen(STRPTR String);
  698. WORD __regargs            GadToolsLongestString(WORD From,WORD To);
  699. STRPTR __regargs        SmallCurrency(VOID);
  700. STRPTR __regargs        CreateSum(LONG Quantity,BYTE UseCurrency);
  701. VOID __regargs            LocalizeString(STRPTR *Strings,WORD From,WORD To);
  702. VOID __regargs            LocalizeMenu(struct NewMenu *Menu,WORD From);
  703. STRPTR __regargs        LocaleString(LONG ID);
  704.  
  705.     /* Packet.c */
  706.  
  707. VOID                ClearPacketHistory(VOID);
  708. VOID __saveds __asm        PacketKey(register __a0 struct Hook *Hook,register __a1 ULONG *Msg,register __a2 struct SGWork *Work);
  709. BYTE                HandlePacket(VOID);
  710. VOID                AddPacketHistory(UBYTE *Buffer);
  711. VOID                DeletePacketWindow(VOID);
  712. BYTE                CreatePacketWindow(VOID);
  713.  
  714.     /* ParseCode.c */
  715.  
  716. VOID                DoCancel(VOID);
  717. VOID                CSIFake(VOID);
  718. BYTE __regargs            ParseCode(UBYTE c);
  719.  
  720.     /* ParseRoutines.c */
  721.  
  722. VOID                ClearCursor(VOID);
  723. VOID                DrawCursor(VOID);
  724. VOID                SetCursor(VOID);
  725. VOID __regargs            ClipBlitCursor(UBYTE DoClip,UBYTE DoMove); 
  726. VOID                BackupRender(VOID);
  727. VOID __regargs            ShiftChar(LONG Size);
  728. VOID                DownLine(VOID);
  729. VOID                ResetCursor(VOID);
  730. UBYTE *                Ignore(VOID);
  731. UBYTE * __regargs        ScrollUp(UBYTE *Buffer);
  732. UBYTE * __regargs        ScrollDown(UBYTE *Buffer);
  733. UBYTE *                CursorScrollDown(VOID);
  734. UBYTE *                CursorScrollUp(VOID);
  735. UBYTE *                NextLine(VOID);
  736. UBYTE *                SaveCursor(VOID);
  737. UBYTE * __regargs        FontStuff(UBYTE *);
  738. UBYTE *                LoadCursor(VOID);
  739. UBYTE * __regargs        ScaleFont(UBYTE *);
  740. UBYTE *                AlignmentTest(VOID);
  741. UBYTE *                SetTab(VOID);
  742. UBYTE * __regargs        RequestTerminal(UBYTE *Buffer);
  743. UBYTE *                Reset(VOID);
  744. UBYTE * __regargs        RequestInformation(UBYTE *Buffer);
  745. UBYTE * __regargs        SetSomething(UBYTE *Buffer);
  746. UBYTE * __regargs        PrinterController(UBYTE *Buffer);
  747. UBYTE * __regargs        NumericAppMode(UBYTE *Buffer);
  748. UBYTE * __regargs        MoveCursor(UBYTE *Buffer);
  749. UBYTE * __regargs        EraseLine(UBYTE *Buffer);
  750. UBYTE * __regargs        EraseScreen(UBYTE *Buffer);
  751. UBYTE * __regargs        EraseCharacters(UBYTE *Buffer);
  752. UBYTE * __regargs        InsertLine(UBYTE *Buffer);
  753. UBYTE * __regargs        ClearLine(UBYTE *Buffer);
  754. UBYTE * __regargs        SetTabs(UBYTE *Buffer);
  755. UBYTE * __regargs        SetAbsolutePosition(UBYTE *Buffer);
  756. UBYTE * __regargs        SetAttributes(UBYTE *Buffer);
  757. UBYTE * __regargs        SetRegion(UBYTE *Buffer);
  758. VOID                ResetCursor(VOID);
  759.  
  760.     /* PathPanel.c */
  761.  
  762. BYTE                PathPanel(struct Configuration *Config);
  763.  
  764.  
  765.     /* PasswordUserPanel.c */
  766.  
  767. VOID                PasswordUserPanel(struct PhoneEntry *Entry);
  768.  
  769.     /* SaveILBM. */
  770.  
  771. LONG                SaveRPort(struct RastPort *RPort,struct ViewPort *VPort,LONG LeftEdge,LONG TopEdge,LONG Width,LONG Height,LONG ParentWidth,LONG ParentHeight,LONG Cookie,STRPTR Name);
  772.  
  773.     /* Scale.c */
  774.  
  775. VOID                DeleteScale(VOID);
  776. BYTE                CreateScale(VOID);
  777. VOID __regargs            PrintScaled(UBYTE *Buffer,LONG Size,UBYTE Scale);
  778.  
  779.     /* Serial.c */
  780.  
  781. VOID                XOn(VOID);
  782. VOID __regargs            SetFlags(struct IOExtSer *SomeRequest);
  783. VOID __regargs            SerialCommand(UBYTE *String);
  784. VOID __regargs            SerWrite(APTR Buffer,LONG Size);
  785. VOID                ClearSerial(VOID);
  786. BYTE                DropDTR(VOID);
  787. VOID                DeleteSerial(VOID);
  788. UBYTE *                CreateSerial(VOID);
  789.  
  790.     /* SpeechPanel.c */
  791.  
  792. VOID                SpeechPanel(VOID);
  793.  
  794.     /* StringHook.c */
  795.  
  796. VOID __saveds            ClipServer(VOID);
  797. VOID __saveds __asm        CommandKey(register __a0 struct Hook *Hook,register __a1 ULONG *Msg,register __a2 struct SGWork *Work);
  798.  
  799.     /* termAux.c */
  800.  
  801. UBYTE * __regargs        ExtractString(UBYTE *String,UBYTE *Destination,BYTE ReturnEnd);
  802. VOID __regargs            DeleteInterleavedBitMap(struct BitMap *SomeBitMap);
  803. struct BitMap * __regargs    CreateInterleavedBitMap(LONG Width,LONG Height,WORD Depth);
  804. struct Node *            GetListNode(LONG Offset,struct List *List);
  805. struct ConUnit *        GetConUnit(struct MsgPort *);
  806. VOID                AddDownloadObject(UBYTE *Line);
  807. VOID                ClearDownloadObjects(VOID);
  808. struct ScanNode *        SequenceFilter(UBYTE Char);
  809. VOID                AddSequenceObject(UBYTE *Sequence);
  810. VOID                ClearSequenceObjects(VOID);
  811. VOID __stdargs            LogAction(UBYTE *String,...);
  812. VOID                FlushMsg(struct Window *Window);
  813. BYTE                GetString(UBYTE *Prompt,UBYTE *Buffer);
  814. VOID __regargs            WakeUp(struct Window *Window,BYTE Activate);
  815. VOID                SendAmigaDOSCommand(UBYTE *Name);
  816. VOID __saveds            RexxBackgroundServer(VOID);
  817. VOID                SendARexxCommand(UBYTE *Name);
  818. LONG                ahtoi(UBYTE *String);
  819. VOID __regargs            BlockWindow(struct Window *Window);
  820. VOID __regargs            ReleaseWindow(struct Window *Window);
  821. VOID                BlockWindows(VOID);
  822. VOID                ReleaseWindows(VOID);
  823. LONG                LineRead(BPTR File,UBYTE *Buffer,LONG MaxChars);
  824. VOID                FlowInit(VOID);
  825. VOID                FlowFilter(UBYTE Char);
  826. BYTE                LoadMacros(UBYTE *Name,struct MacroKeys *Keys);
  827. struct MenuItem *        FindThisItem(ULONG MenuID);
  828. LONG                GetFileSize(UBYTE *Name);
  829. struct FileRequester *        GetFile(UBYTE *Title,UBYTE *Directory,UBYTE *Name,UBYTE *Buffer,UBYTE *Pattern,BYTE SaveFlag,BYTE MultiSelect,BYTE DirsOnly,UBYTE *OKText);
  830. WORD __stdargs            MyEasyRequest(struct Window *Window,UBYTE *Text,UBYTE *Gadgets,...);
  831. VOID                SelectTime(struct PhoneEntry *SomeEntry);
  832. VOID __saveds            StatusServer(VOID);
  833. VOID                CloseWindowSafely(struct Window *Window);
  834. VOID                WaitTime(LONG Secs,LONG Micros);
  835. UBYTE *                GetEnvDOS(UBYTE *Name,UBYTE *Buffer);
  836. BYTE                SetEnvDOS(UBYTE *Name,UBYTE *Value);
  837. VOID                BumpWindow(struct Window *SomeWindow);
  838. VOID                BumpDefault(VOID);
  839. BYTE                WriteIFFData(UBYTE *Name,APTR Data,LONG Size,ULONG Type);
  840. BYTE                ReadIFFData(UBYTE *Name,APTR Data,LONG Size,ULONG Type);
  841. VOID                PushWindow(struct Window *Window);
  842. VOID                PopWindow(VOID);
  843.  
  844.     /* termBuffer.c */
  845.  
  846. VOID __saveds            BufferServer(VOID);
  847. VOID                AddLine(UBYTE *Line,LONG Size);
  848. VOID                ClearBuffer(VOID);
  849. VOID                StoreBuffer(APTR Buffer,LONG Size);
  850.  
  851.     /* termClip.c */
  852.  
  853. BYTE                SaveClip(APTR Buffer,LONG Size);
  854. LONG                LoadClip(APTR Buffer,LONG Size);
  855.  
  856.     /* termCrypt.c */
  857.  
  858. UBYTE *                Encrypt(UBYTE *Source,WORD SourceLen,UBYTE *Destination,UBYTE *Key,WORD KeyLen,BYTE Prefill);
  859. UBYTE *                Decrypt(UBYTE *Source,WORD SourceLen,UBYTE *Destination,UBYTE *Key,WORD KeyLen,BYTE Prefill);
  860. BYTE                CryptPanel(UBYTE *Buffer);
  861.  
  862.     /* termInfo.c */
  863.  
  864. BYTE                ShowInfo(BYTE Ticks);
  865.  
  866.     /* termInit.c */
  867.  
  868. struct Process *        SegmentSplit(STRPTR Name,BYTE Pri,LONG StackSize,APTR Function);
  869. VOID                ConfigSetup(VOID);
  870. BYTE                DeleteDisplay(VOID);
  871. UBYTE *                CreateDisplay(BYTE FirstSetup);
  872. VOID                CloseAll(VOID);
  873. UBYTE *                OpenAll(STRPTR ConfigPath);
  874.  
  875.     /* termHotkeys. */
  876.  
  877. VOID                ShutdownCx(VOID);
  878. BYTE                SetupCx(VOID);
  879.  
  880.     /* termMain.c */
  881.  
  882. LONG __saveds            main(VOID);
  883. VOID __saveds            HandleInput(VOID);
  884. BYTE                HandleWindow(VOID);
  885. BYTE                HandleSerial(VOID);
  886. VOID                HandleCode(ULONG Code,ULONG Qualifier,struct MenuItem *MenuItem);
  887. VOID                HandleMenu(ULONG Code,ULONG Qualifier);
  888.  
  889.     /* termPhone.c */
  890. VOID                RemoveDialEntry(LONG Entry);
  891. VOID                RemoveDialNode(struct PhoneNode *Node);
  892. VOID                SortToList(struct PhoneNode *PhoneNode);
  893. VOID                FreeDialList(VOID);
  894. VOID                SetPrefToDefaults(struct Configuration *Config,UBYTE *PathBuffer);
  895. struct List *            CreatePhoneList(VOID);
  896. VOID                DeletePhoneList(struct List *PhoneList);
  897. VOID                SortPhoneEntries(VOID);
  898. VOID                FreeTimeDateList(struct List *List);
  899. VOID                CopyTimeDateList(struct List *From,struct List *To,BYTE SkipFirst);
  900. VOID                AdaptTimeDateNode(struct TimeDateNode *Node);
  901. struct TimeDateNode *        CreateTimeDateNode(BYTE Month,BYTE Day,UBYTE *Comment);
  902. VOID                RemPhoneEntry(LONG Num);
  903. BYTE                NewPhoneEntry(VOID);
  904. struct PhoneEntry **        CreatePhonebook(LONG Size,LONG *AllocSize,BYTE CreateEntries);
  905. VOID                DeletePhonebook(struct PhoneEntry **,LONG Size,BYTE FreeEntries);
  906. BYTE                SavePhonebook(UBYTE *Name);
  907. BYTE                LoadPhonebook(UBYTE *Name);
  908.  
  909.     /* TerminalPanel.c */
  910.  
  911. VOID                TerminalPanel(struct Configuration *Config);
  912.     /* SerialPanel.c */
  913.  
  914. BYTE                SerialPanel(struct Configuration *Config);
  915.  
  916.     /* ScreenPanel.c */
  917.  
  918. BYTE __regargs            ModeOkay(ULONG ID);
  919. BYTE                ScreenPanel(struct Configuration *Config);
  920.  
  921.     /* PhonePanel.c */
  922.  
  923. BYTE                PhonePanel(VOID);
  924.  
  925.     /* ModemPanel.c */
  926.  
  927. BYTE                ModemPanel(struct Configuration *Config);
  928.  
  929.     /* MacroPanel.c */
  930.  
  931. VOID                MacroPanel(struct MacroKeys *MacroKeys);
  932.  
  933.     /* termRaster.c */
  934.  
  935. VOID                RasterClip(BYTE SingleChar,BYTE Xerox);
  936. VOID                DeleteRaster(VOID);
  937. BYTE                CreateRaster(VOID);
  938. VOID __regargs            RasterEraseScreen(BYTE Mode);
  939. VOID __regargs            RasterEraseLine(BYTE Mode);
  940. VOID __regargs            RasterEraseCharacters(WORD Chars);
  941. VOID __regargs            RasterClearLine(WORD Lines,WORD Top);
  942. VOID __regargs            RasterInsertLine(WORD Lines,WORD Top);
  943. VOID __regargs            RasterScrollRegion(WORD Direction,WORD RasterTop,WORD RasterBottom,WORD RasterLines);
  944. VOID __regargs            RasterShiftChar(WORD Size);
  945. VOID __regargs            RasterPutString(UBYTE *String,WORD Length);
  946.  
  947.     /* termReview.c */
  948.  
  949. VOID                DeleteReview(VOID);
  950. BYTE                CreateReview(VOID);
  951. VOID                UpdateReview(BYTE Force);
  952. BYTE                HandleReview(VOID);
  953.  
  954.     /* termRexx.c */
  955.  
  956. BYTE                SendRexxCommand(struct RexxHost *HostPort,STRPTR CommandString,STRPTR FileExtension,STRPTR HostName);
  957. VOID                FreeRexxCommand(struct RexxMsg *RexxMessage);
  958. VOID                ReplyRexxCommand(struct RexxMsg *RexxMessage,LONG Primary,LONG Secondary,STRPTR Result);
  959. STRPTR                GetToken(STRPTR String,LONG *StartChar,STRPTR AuxBuff,LONG MaxLength);
  960.  
  961. UBYTE *                QueryBaud(VOID);
  962. UBYTE *                QueryDataBits(VOID);
  963. UBYTE *                QueryParity(VOID);
  964. UBYTE *                QueryStopBits(VOID);
  965. UBYTE *                QueryHandshaking(VOID);
  966. UBYTE *                QueryDuplex(VOID);
  967. UBYTE *                QueryHighspeed(VOID);
  968. UBYTE *                QueryBreakLength(VOID);
  969. UBYTE *                QuerySerialDevice(VOID);
  970. UBYTE *                QueryUnitNumber(VOID);
  971. UBYTE *                QueryModemInit(VOID);
  972. UBYTE *                QueryModemExit(VOID);
  973. UBYTE *                QueryDialPrefix(VOID);
  974. UBYTE *                QueryRedialDelay(VOID);
  975. UBYTE *                QueryDialRetries(VOID);
  976. UBYTE *                QueryDialTimeout(VOID);
  977. UBYTE *                QueryConnectAutoBaud(VOID);
  978. UBYTE *                QueryNoCarrier(VOID);
  979. UBYTE *                QueryConnect(VOID);
  980. UBYTE *                QueryError(VOID);
  981. UBYTE *                QueryVoice(VOID);
  982. UBYTE *                QueryRing(VOID);
  983. UBYTE *                QueryBusy(VOID);
  984. UBYTE *                QueryOkay(VOID);
  985. UBYTE *                QueryProtocol(VOID);
  986. UBYTE *                QueryProtocolOptions(VOID);
  987. UBYTE *                QueryMacroFile(VOID);
  988. UBYTE *                QueryDisplay(VOID);
  989. UBYTE *                QueryPublicScreen(VOID);
  990. UBYTE *                QueryShanghai(VOID);
  991. UBYTE *                QueryCaptureFilter(VOID);
  992. UBYTE *                QueryDSBackSpace(VOID);
  993. UBYTE *                QueryAudBell(VOID);
  994. UBYTE *                QueryVisBell(VOID);
  995. UBYTE *                QueryEightyColumns(VOID);
  996. UBYTE *                QuerySendCR(VOID);
  997. UBYTE *                QuerySendLF(VOID);
  998. UBYTE *                QueryColourMode(VOID);
  999. UBYTE *                QueryEmulation(VOID);
  1000. UBYTE *                QueryFont(VOID);
  1001. UBYTE *                QueryStatus(VOID);
  1002. UBYTE *                QuerySerial(VOID);
  1003. UBYTE *                QueryStartup(VOID);
  1004. UBYTE *                QueryRequesters(VOID);
  1005. UBYTE *                QueryTimeout(VOID);
  1006. UBYTE *                QueryLine(VOID);
  1007. UBYTE *                QueryLines(VOID);
  1008. UBYTE *                QueryColumns(VOID);
  1009. UBYTE *                QueryCursor(VOID);
  1010. UBYTE *                QueryModemHangup(VOID);
  1011. UBYTE *                QueryAutoCapture(VOID);
  1012. UBYTE *                QueryLogActions(VOID);
  1013. UBYTE *                QueryBlinking(VOID);
  1014. UBYTE *                QueryCursorMode(VOID);
  1015. UBYTE *                QueryFontScale(VOID);
  1016. UBYTE *                QueryJumpScroll(VOID);
  1017. UBYTE *                QueryCharacterWrap(VOID);
  1018. UBYTE *                QueryCursorWrap(VOID);
  1019. UBYTE *                QueryNewLine(VOID);
  1020. UBYTE *                QueryInsert(VOID);
  1021. UBYTE *                QueryNumeric(VOID);
  1022. UBYTE *                QueryDefaultStore(VOID);
  1023. UBYTE *                QueryTUploadPath(VOID);
  1024. UBYTE *                QueryTDownloadPath(VOID);
  1025. UBYTE *                QueryAUploadPath(VOID);
  1026. UBYTE *                QueryADownloadPath(VOID);
  1027. UBYTE *                QueryBUploadPath(VOID);
  1028. UBYTE *                QueryBDownloadPath(VOID);
  1029. UBYTE *                QueryCapturePath(VOID);
  1030. UBYTE *                QueryLogFile(VOID);
  1031. UBYTE *                QueryEditor(VOID);
  1032. UBYTE *                QueryBeepSound(VOID);
  1033. UBYTE *                QueryCaptureState(VOID);
  1034. UBYTE *                QueryDownloads(VOID);
  1035. UBYTE *                QueryScreenAddress(VOID);
  1036. UBYTE *                QuerySpeechFile(VOID);
  1037. UBYTE *                QuerySpeechRate(VOID);
  1038. UBYTE *                QuerySpeechPitch(VOID);
  1039. UBYTE *                QuerySpeechFrequency(VOID);
  1040. UBYTE *                QuerySpeechVolume(VOID);
  1041. UBYTE *                QuerySpeechSex(VOID);
  1042. UBYTE *                QuerySpeech(VOID);
  1043.  
  1044. VOID                RexxSetBaud(UBYTE *String);
  1045. VOID                RexxSetDataBits(UBYTE *String);
  1046. VOID                RexxSetParity(UBYTE *String);
  1047. VOID                RexxSetStopBits(UBYTE *String);
  1048. VOID                RexxSetHandshaking(UBYTE *String);
  1049. VOID                RexxSetDuplex(UBYTE *String);
  1050. VOID                RexxSetHighSpeed(UBYTE *String);
  1051. VOID                RexxSetBreakLength(UBYTE *String);
  1052. VOID                RexxSetSerialDevice(UBYTE *String);
  1053. VOID                RexxSetUnitNumber(UBYTE *String);
  1054. VOID                RexxSetModemInit(UBYTE *String);
  1055. VOID                RexxSetModemExit(UBYTE *String);
  1056. VOID                RexxSetDialPrefix(UBYTE *String);
  1057. VOID                RexxSetRedialDelay(UBYTE *String);
  1058. VOID                RexxSetDialRetries(UBYTE *String);
  1059. VOID                RexxSetDialTimeout(UBYTE *String);
  1060. VOID                RexxSetConnectAutoBaud(UBYTE *String);
  1061. VOID                RexxSetNoCarrier(UBYTE *String);
  1062. VOID                RexxSetConnect(UBYTE *String);
  1063. VOID                RexxSetError(UBYTE *String);
  1064. VOID                RexxSetVoice(UBYTE *String);
  1065. VOID                RexxSetRing(UBYTE *String);
  1066. VOID                RexxSetBusy(UBYTE *String);
  1067. VOID                RexxSetOkay(UBYTE *String);
  1068. VOID                RexxSetScreenMode(UBYTE *String);
  1069. VOID                RexxSetFilter(UBYTE *String);
  1070. VOID                RexxSetBackspace(UBYTE *String);
  1071. VOID                RexxSetCR(UBYTE *String);
  1072. VOID                RexxSetLF(UBYTE *String);
  1073. VOID                RexxSet80Columns(UBYTE *String);
  1074. VOID                RexxSetColourMode(UBYTE *String);
  1075. VOID                RexxSetEmulation(UBYTE *String);
  1076. VOID                RexxSetStartup(UBYTE *String);
  1077. VOID                RexxSetFont(UBYTE *String);
  1078. VOID                RexxSetProtocol(UBYTE *String);
  1079. VOID                RexxSetProtocolOptions(UBYTE *String);
  1080. VOID                RexxSetMacro(UBYTE *String);
  1081. VOID                RexxSetColour(UBYTE *String);
  1082. VOID                RexxSetScreen(UBYTE *String);
  1083. VOID                RexxSetBell(UBYTE *String);
  1084. VOID                RexxSetMacroFile(UBYTE *String);
  1085. VOID                RexxSetRequesters(UBYTE *String);
  1086. VOID                RexxSetTimeout(UBYTE *String);
  1087. VOID                RexxSetSerial(UBYTE *String);
  1088. VOID                RexxSetModemHangup(UBYTE *String);
  1089. VOID                RexxSetAutoCapture(UBYTE *String);
  1090. VOID                RexxSetLogActions(UBYTE *String);
  1091. VOID                RexxSetBlinking(UBYTE *String);
  1092. VOID                RexxSetCursorMode(UBYTE *String);
  1093. VOID                RexxSetFontScale(UBYTE *String);
  1094. VOID                RexxSetJumpScroll(UBYTE *String);
  1095. VOID                RexxSetCharacterWrap(UBYTE *String);
  1096. VOID                RexxSetCursorWrap(UBYTE *String);
  1097. VOID                RexxSetNewLine(UBYTE *String);
  1098. VOID                RexxSetInsert(UBYTE *String);
  1099. VOID                RexxSetNumeric(UBYTE *String);
  1100. VOID                RexxSetDefaultStore(UBYTE *String);
  1101. VOID                RexxSetTUploadPath(UBYTE *String);
  1102. VOID                RexxSetTDownloadPath(UBYTE *String);
  1103. VOID                RexxSetAUploadPath(UBYTE *String);
  1104. VOID                RexxSetADownloadPath(UBYTE *String);
  1105. VOID                RexxSetBUploadPath(UBYTE *String);
  1106. VOID                RexxSetBDownloadPath(UBYTE *String);
  1107. VOID                RexxSetCapturePath(UBYTE *String);
  1108. VOID                RexxSetLogFile(UBYTE *String);
  1109. VOID                RexxSetEditor(UBYTE *String);
  1110. VOID                RexxSetSpeechRate(UBYTE *String);
  1111. VOID                RexxSetSpeechPitch(UBYTE *String);
  1112. VOID                RexxSetSpeechFrequency(UBYTE *String);
  1113. VOID                RexxSetSpeechVolume(UBYTE *String);
  1114. VOID                RexxSetSpeechSex(UBYTE *String);
  1115. VOID                RexxSetSpeech(UBYTE *String);
  1116.  
  1117. UBYTE *                RexxBreak(VOID);
  1118. UBYTE *                RexxTUpload(UBYTE *String);
  1119. UBYTE *                RexxTDownload(UBYTE *String);
  1120. UBYTE *                RexxBDownload(UBYTE *String);
  1121. UBYTE *                RexxBUpload(UBYTE *String);
  1122. UBYTE *                RexxWrite(UBYTE *String,UBYTE *String2);
  1123. UBYTE *                RexxResetStyles(VOID);
  1124. UBYTE *                RexxClearScreen(VOID);
  1125. UBYTE *                RexxSaveILBM(UBYTE *String);
  1126. UBYTE *                RexxHangUp(VOID);
  1127. UBYTE *                RexxGetString(UBYTE *String);
  1128. UBYTE *                RexxCommand(UBYTE *String,UBYTE *String2);
  1129. UBYTE *                RexxMessage(UBYTE *String,UBYTE *String2);
  1130. UBYTE *                RexxPutClip(UBYTE *String,UBYTE *String2);
  1131. UBYTE *                RexxGetClip(VOID);
  1132. UBYTE *                RexxDelay(UBYTE *String);
  1133. UBYTE *                RexxDial(UBYTE *String);
  1134. UBYTE *                RexxInput(UBYTE *String);
  1135. UBYTE *                RexxPrinter(UBYTE *String);
  1136. UBYTE *                RexxMacros(UBYTE *String);
  1137. UBYTE *                RexxSpeech(UBYTE *String);
  1138. UBYTE *                RexxConfig(UBYTE *String);
  1139. UBYTE *                RexxPhone(UBYTE *String);
  1140. UBYTE *                RexxCapture(UBYTE *String);
  1141. UBYTE *                RexxBuffer(UBYTE *String);
  1142. UBYTE *                RexxFirstDownload(VOID);
  1143. UBYTE *                RexxNextDownload(VOID);
  1144. UBYTE *                RexxLastDownload(VOID);
  1145. UBYTE *                RexxWaitString(UBYTE *String);
  1146. UBYTE *                RexxToneDial(UBYTE *String);
  1147. UBYTE *                RexxSimpleRequest(UBYTE *String);
  1148. UBYTE *                RexxTwoGadRequest(UBYTE *String);
  1149. UBYTE *                RexxFileRequest(UBYTE *String);
  1150. UBYTE *                RexxSpeak(UBYTE *String);
  1151.  
  1152. VOID                QuietExit(VOID);
  1153. VOID                Rexx2Front(VOID);
  1154. VOID                Term2Front(VOID);
  1155. VOID                Display2Front(VOID);
  1156. VOID                CloseDisplay(VOID);
  1157.  
  1158. BYTE                RexxASyncCommand(struct RexxMsg *RexxMsg,UBYTE *Arg1,UBYTE *Arg2);
  1159. VOID                RexxSyncCommand(struct RexxMsg *RexxMsg,UBYTE *Arg1,UBYTE *Arg2);
  1160.  
  1161. VOID __saveds            RexxServer(VOID);
  1162. VOID                HandleRexx(VOID);
  1163.  
  1164.     /* termScroll.c */
  1165.  
  1166. VOID __regargs            ScrollLineRectFill(struct RastPort *RPort,WORD MinX,WORD MinY,WORD MaxX,WORD MaxY);
  1167. VOID __regargs            ScrollLineRaster(struct RastPort *RPort,WORD DeltaX,WORD DeltaY,WORD MinX,WORD MinY,WORD MaxX,WORD MaxY);
  1168.  
  1169. VOID __regargs            ScrollLineEraseScreen(BYTE Mode);
  1170. VOID __regargs            ScrollLineEraseLine(BYTE Mode);
  1171. VOID __regargs            ScrollLineEraseCharacters(WORD Chars);
  1172. VOID __regargs            ScrollLineShiftChar(WORD Size);
  1173. VOID __regargs            ScrollLinePutString(WORD Length);
  1174.  
  1175.     /* termSpeech. */
  1176.  
  1177. VOID                DeleteSpeech(VOID);
  1178. BYTE                CreateSpeech(VOID);
  1179. VOID                Say(UBYTE *String,...);
  1180. VOID                SpeechSetup(VOID);
  1181.  
  1182.     /* termTransfer.c */
  1183.  
  1184. VOID                SendTextFile(UBYTE *TheFile);
  1185. VOID                StartXprReceive(BYTE Type);
  1186. BYTE                StartXprSend(BYTE Type);
  1187. BYTE                ASCIISetup(VOID);
  1188. VOID                ASCIIShutdown(VOID);
  1189.  
  1190.     /* termXEM.c */
  1191.  
  1192. VOID                CloseEmulator(VOID);
  1193. BYTE                OpenEmulator(UBYTE *Name);
  1194. VOID                SetupXEM_MacroKeys(struct MacroKeys *Keys);
  1195.  
  1196.     /* termXPR.c */
  1197.  
  1198. LONG __saveds __asm        xpr_fopen(register __a0 UBYTE *FileName,register __a1 UBYTE *AccessMode);
  1199. LONG __saveds __asm        xpr_fclose(register __a0 struct Buffer *File);
  1200. LONG __saveds __asm        xpr_fread(register __a0 APTR Buffer,register __d0 LONG Size,register __d1 LONG Count,register __a1 struct Buffer *File);
  1201. LONG __saveds __asm        xpr_fwrite(register __a0 APTR Buffer,register __d0 LONG Size,register __d1 LONG Count,register __a1 struct Buffer *File);
  1202. ULONG __saveds __asm        xpr_sread(register __a0 UBYTE *Buffer,register __d0 ULONG Size,register __d1 LONG Timeout);
  1203. LONG __saveds __asm        xpr_swrite(register __a0 UBYTE *Buffer,register __d0 LONG Size);
  1204. LONG __saveds            xpr_sflush(VOID);
  1205. LONG __saveds __asm        xpr_update(register __a0 struct XPR_UPDATE *UpdateInfo);
  1206. LONG __saveds            xpr_chkabort(VOID);
  1207. LONG __saveds __asm        xpr_gets(register __a0 UBYTE *Prompt,register __a1 UBYTE *Buffer);
  1208. LONG __saveds __asm        xpr_setserial(register __d0 LONG Status);
  1209. LONG __saveds __asm        xpr_ffirst(register __a0 UBYTE *Buffer,register __a1 UBYTE *Pattern);
  1210. LONG __saveds __asm        xpr_fnext(register __d0 LONG OldState,register __a0 UBYTE *Buffer,register __a1 UBYTE *Pattern);
  1211. LONG __saveds __asm        xpr_finfo(register __a0 UBYTE *FileName,register __d0 LONG InfoType);
  1212. LONG __saveds __asm        xpr_fseek(register __a0 struct Buffer *File,register __d0 LONG Offset,register __d1 LONG Origin);
  1213. ULONG __saveds __asm        xpr_options(register __d0 LONG NumOpts,register __a0 struct xpr_option **Opts);
  1214. LONG __saveds __asm        xpr_unlink(register __a0 UBYTE *FileName);
  1215. LONG __saveds            xpr_squery(VOID);
  1216. LONG __saveds __asm        xpr_getptr(register __d0 LONG InfoType);
  1217. LONG __saveds __asm        xpr_stealopts(register __a0 UBYTE *Prompt,register __a1 UBYTE *Buffer);
  1218.  
  1219. struct Gadget *            CreateAllGetsGadgets(BYTE LoadGadget,UBYTE *String,UBYTE *Prompt,LONG *WindowWidth,struct Gadget **GadgetArray,struct Gadget **GadgetList,APTR VisualInfo,UWORD TopEdge,struct Screen *Screen);
  1220.  
  1221. BYTE                ProtocolSetup(VOID);
  1222. VOID                SaveProtocolOpts(VOID);
  1223. BYTE                SelectProtocol(UBYTE *Name,struct Window *ParentWindow);
  1224.  
  1225.     /* ToneDial.c */
  1226.  
  1227. VOID                DeleteTone(VOID);
  1228. BYTE                ToneDial(UBYTE *Number);
  1229.  
  1230.     /* TransferPanel.c */
  1231.  
  1232. VOID __stdargs            TransferInfo(WORD X,WORD Y,BYTE *String,...);
  1233. VOID __stdargs            ShowString(struct Gadget *Gadget,UBYTE *String,...);
  1234. VOID                GhostStats(struct Gadget *Gadget);
  1235. VOID                ShowStats(struct Gadget *Gadget,LONG Value,LONG Max);
  1236. VOID __stdargs            AddTransferInfo(UBYTE *Message,...);
  1237. VOID                RefreshTransferWindow(VOID);
  1238. BYTE                TransferPanel(UBYTE *Title);
  1239. VOID                DeleteTransferPanel(VOID);
  1240.  
  1241.     /* RatePanel.c */
  1242.  
  1243. VOID                RatePanel(struct List *PhoneList,struct PhoneEntry *Entry);
  1244.  
  1245.     /* UploadPanel.c */
  1246.  
  1247. BYTE                UploadPanel(VOID);
  1248.  
  1249.     /* Format.asm */
  1250.  
  1251. VOID __stdargs            SPrintf(APTR,UBYTE *,...);
  1252. VOID __stdargs            VSPrintf(APTR,UBYTE *,va_list);
  1253.  
  1254.     /* termData.c */
  1255.  
  1256. extern struct ExecBase        *SysBase;
  1257. extern struct DosLibrary    *DOSBase;
  1258.  
  1259. extern struct IntuitionBase    *IntuitionBase;
  1260. extern struct GfxBase        *GfxBase;
  1261. extern struct Library        *GadToolsBase;
  1262. extern struct Library        *DiskfontBase;
  1263. extern struct Library        *UtilityBase;
  1264. extern struct Device        *TimerBase;
  1265. extern struct Library        *AslBase;
  1266. extern struct RxsLib        *RexxSysBase;
  1267. extern struct Library        *IFFParseBase;
  1268. extern struct Library        *CxBase;
  1269. extern struct Library        *LayersBase;
  1270. extern struct Library        *IconBase;
  1271. extern struct Library        *WorkbenchBase;
  1272. extern struct Library        *XEmulatorBase;
  1273.  
  1274. extern struct timerequest    *TimeRequest;
  1275. extern struct MsgPort        *TimePort;
  1276.  
  1277. extern struct IOStdReq        *ConsoleRequest;
  1278. extern struct Device        *ConsoleDevice;
  1279. extern struct KeyMap        *KeyMap;
  1280. extern BPTR             KeySegment;
  1281.  
  1282. extern struct Screen        *Screen;
  1283. extern struct Window        *Window;
  1284. extern struct Window        *StatusWindow;
  1285. extern UWORD             StatusOffset;
  1286. extern APTR             OldWindowPtr;
  1287. extern struct BitMap        *InterleavedBitMap;
  1288. extern struct Requester        *RequesterList;
  1289.  
  1290. extern struct ViewPort        *VPort;
  1291. extern struct RastPort        *RPort;
  1292. extern struct TextFont        *Topaz,*IBM,*GFX,*CurrentFont;
  1293. extern APTR             VisualInfo;
  1294.  
  1295. extern UWORD             ANSIPens[NUMDRIPENS + 1];
  1296. extern UWORD             EGAPens[NUMDRIPENS + 1];
  1297. extern UWORD             AtomicColours[16];
  1298. extern UWORD             EGAColours[16];
  1299. extern UWORD             ANSIColours[16];
  1300. extern UWORD             DefaultColours[16];
  1301. extern UWORD             BlinkColours[16];
  1302. extern UWORD             StandardColours[16];
  1303.  
  1304. extern struct Process        *ThisProcess;
  1305. extern struct Process        *RexxProcess;
  1306. extern struct MsgPort        *TermRexxPort;
  1307. extern struct Process        *StatusProcess;
  1308. extern struct Process        *BufferProcess;
  1309. extern struct WBStartup        *WBenchMsg;
  1310.  
  1311. extern struct InputEvent    *FakeInputEvent;
  1312.  
  1313. extern struct IOExtSer        *ReadRequest;
  1314. extern struct IOExtSer        *WriteRequest;
  1315. extern struct MsgPort        *ReadPort;
  1316. extern APTR             ReadBuffer,
  1317.                  HostReadBuffer;
  1318. extern UBYTE            *SerialMessage;
  1319.  
  1320. extern struct Hotkeys         Hotkeys;
  1321. extern struct NewBroker         NewTermBroker;
  1322.  
  1323. extern struct TextAttr         DefaultFont;
  1324. extern struct TextAttr         IBMFont;
  1325. extern struct TextAttr         GFXFont;
  1326.  
  1327. extern UBYTE             AnyChannel[4];
  1328.  
  1329. extern UBYTE __chip         SineWave[8];
  1330.  
  1331. extern struct IOAudio        *AudioBlock;
  1332.  
  1333. extern UWORD __chip         Stopwatch[(2 + 16) * 2];
  1334.  
  1335. extern BYTE             ValidTab[256];
  1336. extern UBYTE             IBMConversion[256];
  1337. extern BYTE             GfxTable[256];
  1338.  
  1339. extern struct SpecialKey     SpecialKeys[11];
  1340. extern UBYTE             SpecialMap[256];
  1341.  
  1342. extern UBYTE             SharedBuffer[512];
  1343.  
  1344. extern struct NewMenu         TermMenu[];
  1345. extern struct Menu        *Menu;
  1346.  
  1347. extern struct TermPort        *TermPort;
  1348.  
  1349. extern struct Configuration     Config;
  1350. extern struct Configuration     PrivateConfig;
  1351. extern struct SpeechConfig     SpeechConfig;
  1352. extern BYTE             English;
  1353. extern BYTE             Status;
  1354. extern BYTE             Online;
  1355. extern struct Configuration    *BackupConfig;
  1356. extern UWORD             PublicModes;
  1357.  
  1358. extern UBYTE             LastConfig[256];
  1359. extern UBYTE             DefaultPubScreen[MAXPUBSCREENNAME];
  1360.  
  1361. extern ULONG             ModeID[16];
  1362.  
  1363. extern struct Buffer        *FileCapture;
  1364. extern BPTR             PrinterCapture;
  1365. extern UBYTE             CaptureName[256];
  1366. extern BYTE             StandardPrinterCapture,
  1367.                  ControllerActive;
  1368.  
  1369. extern UBYTE            **BufferLines;
  1370. extern LONG             Lines;
  1371. extern struct SignalSemaphore    *BufferSemaphore;
  1372. extern LONG             MaxLines;
  1373. extern LONG             BufferSpace;
  1374. extern BYTE             BufferClosed;
  1375. extern BYTE             BufferFrozen;
  1376.  
  1377. extern struct PhoneEntry    **Phonebook;
  1378. extern LONG             PhoneSize;
  1379. extern LONG             NumPhoneEntries;
  1380. extern UBYTE             PhonePassword[256];
  1381. extern BYTE             PhonePasswordUsed;
  1382.  
  1383. extern UBYTE             LastPhone[256];
  1384. extern UBYTE             LastKeys[256];
  1385. extern UBYTE             LastMacros[256];
  1386. extern UBYTE             LastSpeech[256];
  1387.  
  1388. extern struct MacroKeys        *MacroKeys;
  1389.  
  1390. extern UBYTE            *StripBuffer;
  1391.  
  1392. extern UWORD             LastLine,LastColumn,LastPixel;
  1393. extern BYTE             Charset,Attributes,FgPen,BgPen;
  1394. extern WORD             CursorX,CursorY,Top,Bottom;
  1395. extern BYTE             UseRegion,RegionSet,InSequence,Quiet,Blocking;
  1396. extern BYTE             TabStops[1024];
  1397. extern BYTE             CharMode[2];
  1398.  
  1399. extern BYTE             ResetDisplay,Escape;
  1400.  
  1401. extern UBYTE            *AttentionBuffers[8],AttentionCount[8],FlowCount;
  1402. extern BYTE             BaudPending,FullCheck;
  1403. extern UBYTE             BaudBuffer[20],BaudCount;
  1404.  
  1405. extern struct FlowInfo         FlowInfo;
  1406.  
  1407. extern LONG             FileCount,FileCountMax;
  1408. extern struct WBArg        *FileArg;
  1409. extern BYTE             MultipleFiles,FileMatch,BinaryTransfer;
  1410. extern struct AnchorPath    *FileAnchor;
  1411. extern LONG             TransferBits;
  1412.  
  1413. extern struct Window        *TransferWindow;
  1414. extern struct Menu        *TransferMenu;
  1415. extern struct Gadget        *TransferGadgetArray[8];
  1416. extern struct List         TransferInfoList;
  1417.  
  1418. extern UBYTE            *DownloadPath;
  1419. extern BYTE             Uploading;
  1420. extern BYTE             DidTransfer;
  1421.  
  1422. extern struct Library        *XProtocolBase;
  1423. extern struct XPR_IO        *XprIO;
  1424.  
  1425. extern UBYTE             ProtocolOptsBuffer[256];
  1426. extern BYTE             NewLibrary,NewOptions;
  1427. extern UBYTE             LastXprLibrary[256];
  1428. extern UBYTE             ConvNumber[30],ConvNumber10[30];
  1429. extern BYTE             UsesZModem,SendAbort,TransferAborted;
  1430.  
  1431. extern UBYTE             ZModemCancel[20];
  1432.  
  1433. extern LONG             CurrentPay;
  1434. extern LONG             PayPerUnit[2];
  1435. extern LONG             SecPerUnit[2];
  1436. extern LONG             TimeOfDay[2];
  1437. extern WORD             PreferredTime;
  1438. extern UBYTE             Password[20];
  1439. extern UBYTE             UserName[20];
  1440. extern struct PhoneEntry    *ChosenEntry;
  1441. extern BYTE             ChosenInUse;
  1442.  
  1443. extern UBYTE             WindowName[256];
  1444.  
  1445. extern BYTE             WeAreBlocking;
  1446.  
  1447. extern struct List        *DialList;
  1448.  
  1449. extern BYTE             SendStartup;
  1450.  
  1451. extern BYTE             ReleaseSerial;
  1452. extern BYTE             ResetSerial;
  1453. extern BYTE             BatchMode;
  1454. extern BYTE             SerialSet;
  1455.  
  1456. extern UBYTE             LastDownload[256];
  1457. extern UBYTE             LastUpload[256];
  1458.  
  1459. extern struct Hook         CommandHook;
  1460. extern BYTE             DontActivate;
  1461. extern UBYTE             CommandWorkBuffer[256];
  1462. extern struct StringExtend     CommandExtend;
  1463. extern struct Window        *CommandWindow;
  1464. extern struct Gadget        *CommandGadget;
  1465. extern struct Gadget        *ActiveGadget;
  1466.  
  1467. extern struct Process        *ClipProcess;
  1468. extern struct MsgPort        *ClipPort;
  1469.  
  1470. extern struct Window        *PacketWindow;
  1471. extern struct Gadget        *PacketGadgetArray[2];
  1472. extern struct Menu        *PacketMenu;
  1473. extern struct Gadget        *PacketGadgetList;
  1474. extern struct List         PacketHistoryList;
  1475.  
  1476. extern struct NewMenu         GetsMenu[];
  1477.  
  1478. extern BYTE             Initializing,LoadColours;
  1479.  
  1480. extern UBYTE            *Raster,*RasterAttr;
  1481. extern WORD             RasterWidth,RasterHeight;
  1482.  
  1483. extern struct SignalSemaphore    *DownloadSemaphore;
  1484. extern struct List         DownloadList;
  1485. extern LONG             DownloadLineCount;
  1486. extern struct Node        *DownloadNode;
  1487.  
  1488. extern struct List         SequenceList;
  1489. extern LONG             SequenceCount;
  1490.  
  1491. extern ULONG             VersionProps[2];
  1492.  
  1493. extern BYTE             ExitQuietly;
  1494.  
  1495. extern struct Window        *RexxWindow;
  1496.  
  1497. extern struct Window        *TopWindow;
  1498. extern struct Window        *WindowStack[5];
  1499. extern WORD             WindowStackPtr;
  1500.  
  1501. extern LONG             TermID;
  1502. extern UBYTE             TermIDString[];
  1503.  
  1504. extern struct List         FastMacroList;
  1505. extern LONG             FastMacroCount;
  1506. extern UBYTE             LastFastMacros[256];
  1507. extern struct Window        *FastWindow;
  1508. extern struct Gadget        *FastGadget;
  1509.  
  1510. extern struct List         DoubleBufferList;
  1511. extern struct SignalSemaphore     DoubleBufferSemaphore;
  1512.  
  1513. extern struct XEM_IO        *XEM_IO;
  1514. extern ULONG             XEM_Signal;
  1515. extern struct XEmulatorHostData     XEM_HostData;
  1516. extern UBYTE            *OptionTitle;
  1517. extern struct List         XEM_MacroList;
  1518. extern struct XEmulatorMacroKey    *XEM_MacroKeys;
  1519. extern UBYTE             EmulationName[40];
  1520.  
  1521. extern struct List         EmptyList;
  1522.  
  1523. extern UBYTE             ScrollLineFirst,ScrollLineLast,
  1524.                  ScrollLineCount;
  1525. extern struct ScrollLineInfo    *ScrollLines;
  1526.  
  1527. extern struct MsgPort        *ReviewPort;
  1528. extern struct Window        *ReviewWindow;
  1529.